Thank you!

I wonder if the warning is useful. save_hyperparameters is explicit that it picks up the argument from the class __init__, and field(init=False) quite explicitly excludes the attribute from the __init__.

I encountered #21036 by doing exactly what the warning suggests to do: by initializing the attributes in __post_init__ while using @dataclasses.dataclass.
The need for dataclasses.field(init=False) comes from type annotations: I want those __post_init__-initialized attributes (typically the nn.Module that make up the model) to be type-annotated (for better IDE integration/completion & type-checking). Since @dataclasses.dataclass would add any such attributes to the __init__ by default, I need to exclude them with init=False.

In that case, the warning would instruct the user to do exactly what they're already doing, which might be confusing and make them wonder what they should do exactly.

WDYT?

Thank you!

I wonder if the warning is useful. save_hyperparameters is explicit that it picks up the argument from the class __init__, and field(init=False) quite explicitly excludes the attribute from the __init__.

I encountered #21036 by doing exactly what the warning suggests to do: by initializing the attributes in __post_init__ while using @dataclasses.dataclass. The need for dataclasses.field(init=False) comes from type annotations: I want those __post_init__-initialized attributes (typically the nn.Module that make up the model) to be type-annotated (for better IDE integration/completion & type-checking). Since @dataclasses.dataclass would add any such attributes to the __init__ by default, I need to exclude them with init=False.

In that case, the warning would instruct the user to do exactly what they're already doing, which might be confusing and make them wonder what they should do exactly.

WDYT?

@QuentinSoubeyranAqemia what I was thinking that users would need to do, would be something like this

import dataclasses

import lightning.pytorch as L

@dataclasses.dataclass
class Module(L.LightningModule):
    a: float
    b: float
    c: float = 0.0

    def __post_init__(self):
        self.c = self.a + self.b
        self.save_hyperparameters()

model = Module(a=1, b=2)
print(model.hparams)

this is kind of misuse of dataclasses but should still have type checking and being correctly saved in self.hparams by using self.save_hyperparameters(). I really think that the warning should be there, but maybe the wording should be different.

Perhaps the minimal reproducing example I provided is causing some confusion. In practice, the attributes that needs to be excluded with field(init=False) need to be excluded exactly because they are not hyper-parameters -- else they would be part of __init__.

The use-case is for internal nn.Module that need to be initialized in __post_init__ once dataclasses has stored the hparams into attributes for us. Those nn.Module attributes must not be part of __init__ nor save_hyperparameters. They cannot be initialized with a field(default=...) or field(default_factory=...) because they depend on the hyper-parameters.

Here's an example which is hopefully clearer: transforming a (simplistic) vanilla lightning module to leverage @dataclasses.dataclass to write the boilerplate of storing hparams into attribute for us:

import lightning.pytorch as L

class Module(L.LightningModule):
    input_dim: int
    hparam: int
    readout_dim: int

    model: MyModule
    readout: nn.Linear

    # we need to write a boilerplate signature again, though it is already laid out above
    def __init__(self, input_dim: int, hparam: int, readout_dim: int):
        super().__init__()
        self.save_hyperparameters()
        # boilerplate to store hyper-parameters
        sefl.input_dim = input_dim
        self.hparam = hparam
        self.readout_dim = readout_dim
        # create internals
        self.model = MyModule(self.input_dim, self.hparam) # nn.Module
        self.readout = nn.Linear(..., self.readout_dim)

into the more concise

import lightning.pytorch as L

import dataclasses

@dataclasses.dataclass(...) # some specific flag needed here, not the point of this discussion
class Module(L.LightningModule):
    input_dim: int
    hidden_dim: Sequence[int]
    readout_dim: int
    
    # internals, not hparams, exclude them from __init__ and save_hyperparameters()
    model: MyModule = dataclasses.field(init=False)
    readout: nn.Linear = dataclasses.field(init=False)

    def __post_init__(self):
        # no boilerplate !
        super().__init__()
        self.save_hyperparameters()
        self.model = MyModule(self.input_dim, self.hparam) # nn.Module
        self.readout = nn.Linear(..., self.readout_dim)

@QuentinSoubeyranAqemia thanks for expanding on the use case, it all makes sense now. I have removed the warning since you are right that it does not make sense